/**
 * WebXR音频权限解决方案
 * 专门处理WebXR模式下的音频权限请求和激活
 */

// 导入音频上下文单例
import audioContextSingleton from './audio-context-singleton.js';
export class WebXRAudioSolution {
    constructor() {
        this.audioEnabled = false;
        // 不在这里自动初始化，让调用者决定何时初始化
    }

    async init() {
        try {
            console.log('🎵 WebXRAudioSolution初始化中...');
            
            // 使用音频上下文单例
            this.audioContext = audioContextSingleton.getContext({
                sampleRate: 48000,
                latencyHint: 'interactive'
            });
            
            // 初始化音频源和分析器
            this._initAudioNodes();
            
            // 监听音频上下文状态变化
            this.audioContext.addEventListener('statechange', this._handleStateChange.bind(this));
            
            // 为可能的用户交互添加监听器，以确保音频上下文能够恢复
            this._setupUserInteractionListeners();
            
            // 监听UnifiedXRManager事件（如果可用）
            this._setupXRManagerListeners();
            
            // 尝试预授权
            await this.tryPreemptiveAuthorization();
            
            // 设置XR音频处理
            this.setupXRAudioHandlers();
            
            console.log('✅ WebXRAudioSolution初始化完成');
            return Promise.resolve(this);
        } catch (error) {
            console.error('❌ WebXRAudioSolution初始化失败:', error);
            return Promise.reject(error);
        }
    }
    
    /**
     * 尝试预授权音频访问
     */
    async tryPreemptiveAuthorization() {
        try {
            console.log('🔐 WebXRAudioSolution尝试预授权音频访问');
            // 在用户交互时尝试恢复音频上下文
            if (this.audioContext.state === 'suspended') {
                await this.audioContext.resume();
                console.log('✅ 音频上下文已恢复');
            }
            return true;
        } catch (error) {
            console.warn('⚠️ 预授权失败:', error);
            return false;
        }
    }
    
    /**
     * 设置XR音频处理
     */
    setupXRAudioHandlers() {
        console.log('🎧 WebXRAudioSolution设置XR音频处理');
        
        // 这里可以添加特定于XR的音频处理逻辑
        // 例如空间音频配置、音频路由等
    }
    
    _initAudioNodes() {
        // 初始化音频节点
        console.log('🔊 WebXRAudioSolution初始化音频节点');
        
        // 创建音频分析器
        this.analyser = this.audioContext.createAnalyser();
        this.analyser.fftSize = 256;
        
        // 创建增益节点
        this.gainNode = this.audioContext.createGain();
        
        // 连接节点
        this.gainNode.connect(this.analyser);
        this.analyser.connect(this.audioContext.destination);
        
        console.log('✅ 音频节点初始化完成');
    }
    
    _handleStateChange(event) {
        console.log('🎵 WebXRAudioSolution音频上下文状态变更为:', this.audioContext.state);
    }
    
    _setupUserInteractionListeners() {
        // 设置用户交互监听器
        document.addEventListener('click', this.ensureAudioActive.bind(this));
        document.addEventListener('touchstart', this.ensureAudioActive.bind(this));
        console.log('👆 WebXRAudioSolution设置用户交互监听器');
    }
    
    /**
     * 设置UnifiedXRManager事件监听器
     */
    _setupXRManagerListeners() {
        try {
            console.log('🔌 WebXRAudioSolution设置XR管理器事件监听器');
            
            // 方式1：尝试通过window.app.xrManager访问
            if (window.app && window.app.xrManager) {
                const xrManager = window.app.xrManager;
                this._bindToXRManager(xrManager);
                return;
            }
            
            // 方式2：尝试通过window._xrManager访问（如果UnifiedXRManager已创建但未绑定到app）
            if (window._xrManager) {
                const xrManager = window._xrManager;
                this._bindToXRManager(xrManager);
                return;
            }
            
            // 方式3：监听全局事件
            this._setupGlobalXREventListeners();
            
            console.log('⚠️ WebXRAudioSolution未找到XR管理器实例，将使用全局事件监听作为后备方案');
        } catch (error) {
            console.error('❌ 设置XR管理器事件监听器失败:', error);
            // 回退到全局事件监听
            this._setupGlobalXREventListeners();
        }
    }
    
    /**
     * 绑定到XR管理器实例
     */
    _bindToXRManager(xrManager) {
        console.log('✅ WebXRAudioSolution绑定到XR管理器实例');
        
        // 尝试绑定事件（根据UnifiedXRManager的事件系统实现）
        if (typeof xrManager.on === 'function') {
            // 如果实现了on/off事件系统
            xrManager.on('xr-session-start', this._handleXRSessionStart.bind(this));
            xrManager.on('xr-session-end', this._handleXRSessionEnd.bind(this));
            console.log('🔗 WebXRAudioSolution绑定到XR管理器的on/off事件系统');
        } else if (typeof xrManager.addEventListener === 'function') {
            // 如果实现了addEventListener事件系统
            xrManager.addEventListener('xr-session-start', this._handleXRSessionStart.bind(this));
            xrManager.addEventListener('xr-session-end', this._handleXRSessionEnd.bind(this));
            console.log('🔗 WebXRAudioSolution绑定到XR管理器的addEventListener事件系统');
        } else if (typeof xrManager.addListener === 'function') {
            // 如果实现了addListener事件系统
            xrManager.addListener('xr-session-start', this._handleXRSessionStart.bind(this));
            xrManager.addListener('xr-session-end', this._handleXRSessionEnd.bind(this));
            console.log('🔗 WebXRAudioSolution绑定到XR管理器的addListener事件系统');
        }
    }
    
    /**
     * 设置全局XR事件监听器（作为后备方案）
     */
    _setupGlobalXREventListeners() {
        // 先清理已有的监听器，避免重复绑定
        this._removeGlobalXREventListeners();
        
        console.log('🌐 WebXRAudioSolution设置全局XR事件监听器');
        
        // 保存事件处理函数的引用，以便后续移除
        this._xrEventHandlers = {
            xrstart: this._handleXRSessionStart.bind(this),
            xrend: this._handleXRSessionEnd.bind(this),
            vractivate: this._handleXRSessionStart.bind(this),
            vrdeactivate: this._handleXRSessionEnd.bind(this)
        };
        
        // 监听全局WebXR事件
        window.addEventListener('webxr:xrstart', this._xrEventHandlers.xrstart);
        window.addEventListener('webxr:xrend', this._xrEventHandlers.xrend);
        
        // 监听自定义VR事件
        window.addEventListener('vr-activate', this._xrEventHandlers.vractivate);
        window.addEventListener('vr-deactivate', this._xrEventHandlers.vrdeactivate);
    }
    
    /**
     * 移除全局XR事件监听器
     */
    _removeGlobalXREventListeners() {
        console.log('🧹 WebXRAudioSolution: 清理XR事件监听器');
        
        // 如果没有保存的事件处理器，直接返回
        if (!this._xrEventHandlers) {
            return;
        }
        
        // 移除XR会话开始事件监听器
        if (this._xrEventHandlers.xrstart) {
            window.removeEventListener('webxr:xrstart', this._xrEventHandlers.xrstart);
        }
        
        // 移除XR会话结束事件监听器
        if (this._xrEventHandlers.xrend) {
            window.removeEventListener('webxr:xrend', this._xrEventHandlers.xrend);
        }
        
        // 移除VR激活事件监听器
        if (this._xrEventHandlers.vractivate) {
            window.removeEventListener('vr-activate', this._xrEventHandlers.vractivate);
        }
        
        // 移除VR停用事件监听器
        if (this._xrEventHandlers.vrdeactivate) {
            window.removeEventListener('vr-deactivate', this._xrEventHandlers.vrdeactivate);
        }
        
        // 清空事件处理器对象
        this._xrEventHandlers = null;
    }
    
    /**
     * 销毁实例
     */
    destroy() {
        console.log('💥 WebXRAudioSolution: 销毁实例');
        
        // 移除所有事件监听器
        this._removeGlobalXREventListeners();
        
        // 清理其他资源
        // ...
    }
    
    /**
     * 处理XR会话开始
     */
    _handleXRSessionStart(event) {
        console.log('🎯 WebXRAudioSolution检测到XR会话开始');
        
        // 确保音频上下文处于活动状态
        this.ensureAudioActive();
        
        // 如果有活跃的语音识别，确保它在XR模式下正确工作
        if (window.app && window.app.voiceManager && window.app.voiceManager.isListening) {
            window.app.voiceManager.restartListening();
        }
    }
    
    /**
     * 处理XR会话结束
     */
    _handleXRSessionEnd(event) {
        console.log('🎯 WebXRAudioSolution检测到XR会话结束');
        
        // 在XR会话结束时，保持音频上下文活跃，不要停止语音识别
        // 这样可以确保用户在XR会话结束后仍然可以继续对话
        if (window.app && window.app.voiceManager) {
            console.log('🎯 WebXRAudioSolution：保持音频系统活跃，支持连续对话');
            // 确保音频上下文仍然保持活跃状态
            this.ensureAudioActive();
        }
    }
    
    /**
     * 确保音频上下文处于活动状态
     */
    ensureAudioActive() {
        if (this.audioContext && this.audioContext.state === 'suspended') {
            this.audioContext.resume().then(() => {
                console.log('✅ WebXRAudioSolution音频上下文已恢复活动状态');
            }).catch(error => {
                console.error('❌ WebXRAudioSolution无法恢复音频上下文:', error);
            });
        }
    }

    async tryPreemptiveAuthorization() {
        // 在用户第一次交互时尝试预授权
        document.addEventListener('click', async () => {
            if (!this.audioEnabled) {
                await this.enableAudioSystem();
            }
        }, { once: true });
    }

    setupXRAudioHandlers() {
        // 监听XR会话事件
        if (navigator.xr) {
            navigator.xr.addEventListener('sessiongranted', (event) => {
                console.log('🎮 XR会话已授权，检查音频权限');
                this.checkAndRequestAudioPermission();
            });
        }
        
        // 监听全局XR管理器的事件
        if (window._xrManager) {
            // 如果XR管理器有addEventListener方法，使用标准事件API
            if (window._xrManager.addEventListener) {
                window._xrManager.addEventListener('xr-session-start', () => {
                    console.log('🎮 XR管理器通知会话开始，检查音频权限');
                    this.checkAndRequestAudioPermission();
                });
            } 
            // 否则尝试使用自定义的on方法（UnifiedXRManager使用的事件系统）
            else if (window._xrManager.on) {
                window._xrManager.on('xr-session-start', () => {
                    console.log('🎮 XR管理器通知会话开始（使用自定义on方法），检查音频权限');
                    this.checkAndRequestAudioPermission();
                });
            }
        } else {
            // 等待XR管理器初始化
            const checkXRManager = setInterval(() => {
                if (window._xrManager) {
                    clearInterval(checkXRManager);
                    // 尝试添加事件监听器
                    if (window._xrManager.addEventListener) {
                        window._xrManager.addEventListener('xr-session-start', () => {
                            console.log('🎮 XR管理器通知会话开始，检查音频权限');
                            this.checkAndRequestAudioPermission();
                        });
                    }
                    // 否则尝试使用自定义的on方法
                    else if (window._xrManager.on) {
                        window._xrManager.on('xr-session-start', () => {
                            console.log('🎮 XR管理器通知会话开始（使用自定义on方法），检查音频权限');
                            this.checkAndRequestAudioPermission();
                        });
                    }
                    else {
                        console.warn('⚠️ XR管理器不支持事件监听');
                    }
                }
            }, 500);
            
            // 10秒后停止检查
            setTimeout(() => clearInterval(checkXRManager), 10000);
        }
    }

    // 复用AudioPermissionManager的UI，不再创建单独的对话框
    preparePermissionUI() {
        console.log('🎵 WebXRAudioSolution复用AudioPermissionManager的UI');
    }
    
    createAudioPermissionDialog() {
        console.log('🎵 WebXRAudioSolution不再创建对话框，由AudioPermissionManager负责');
    }

    async enableAudioSystem() {
        try {
            console.log('🔄 开始启用音频系统...');
            
            // 显示加载状态
            this.showLoadingState();
            
            // 完整的音频系统启用流程
            await this.requestAudioPermission();
            
            // 统一使用initializeAudioContext方法创建或获取音频上下文，避免重复创建
            const audioContext = await this.initializeAudioContext();
            console.log('✅ 音频上下文已准备就绪，状态:', audioContext.state);
            
            // 确保音频上下文处于活动状态
            if (audioContext.state === 'suspended') {
                await audioContext.resume();
                console.log('✅ 音频上下文已成功恢复');
            }
            await this.reinitVoiceSystems();
            
            // 播放一个短暂的测试音，确认音频通道已打开
            const oscillator = audioContext.createOscillator();
            const gainNode = audioContext.createGain();
            
            oscillator.connect(gainNode);
            gainNode.connect(audioContext.destination);
            
            oscillator.type = 'sine';
            oscillator.frequency.value = 440; // 440 Hz (A4)
            gainNode.gain.value = 0.1; // 低音量
            
            oscillator.start();
            gainNode.gain.exponentialRampToValueAtTime(0.001, audioContext.currentTime + 0.3);
            
            setTimeout(() => {
                oscillator.stop();
                console.log('✅ 测试音播放完成');
            }, 300);
            
            this.audioEnabled = true;
            this.hidePermissionDialog();
            
            console.log('🎉 WebXR音频系统已完全启用');
            
            // 通知全局应用
            if (window.app) {
                try {
                    // 检查是否有AudioPermissionManager
                    if (window.app.audioPermissionManager) {
                        console.log('✅ 通过AudioPermissionManager通知音频权限已授予');
                        window.app.audioPermissionManager.audioPermissionGranted = true;
                        window.app.audioPermissionManager.notifyPermissionGranted();
                    } else if (window.app.dispatchEvent && typeof window.app.dispatchEvent === 'function') {
                        // 使用事件系统通知
                        window.app.dispatchEvent(new CustomEvent('audio-permission-granted'));
                    }
                } catch (error) {
                    console.warn('⚠️ 通知音频权限时出错:', error);
                }
            }
            
        } catch (error) {
            console.error('❌ 音频系统启用失败:', error);
            this.showErrorFallback();
        }
    }

    async requestAudioPermission() {
        try {
            // 尝试获取麦克风权限（这会同时触发音频权限请求）
            const stream = await navigator.mediaDevices.getUserMedia({
                audio: {
                    echoCancellation: true,
                    noiseSuppression: true,
                    autoGainControl: true
                }
            });
            
            // 停止流，但保留权限
            stream.getTracks().forEach(track => track.stop());
            
            console.log('✅ 音频权限请求成功');
        } catch (error) {
            console.warn('⚠️ 音频权限请求失败，但继续尝试:', error);
            // 不抛出错误，继续尝试其他方法
        }
    }

    async initializeAudioContext() {
        try {
            // 核心优化：如果已有上下文则复用，避免重复创建
            // 优先使用VoiceManager中已有的音频上下文
            if (window.app?.voiceManager && window.app.voiceManager.audioContext) {
                console.log('🎯 复用VoiceManager中的音频上下文');
                const audioContext = window.app.voiceManager.audioContext;
                
                // 确保复用的上下文处于活动状态
                if (audioContext.state === 'suspended') {
                    await audioContext.resume();
                    console.log('✅ 复用的音频上下文已恢复');
                    // 同步状态到VoiceManager
                    if (window.app.voiceManager) {
                        window.app.voiceManager.audioContextSuspended = false;
                    }
                }
                return audioContext;
            }
            
            // 如果没有VoiceManager的上下文，创建新的
            const AudioContext = window.AudioContext || window.webkitAudioContext;
            const audioContext = new AudioContext();
            console.log('✅ 创建新的音频上下文');
            return audioContext;
        } catch (error) {
            console.error('❌ 初始化音频上下文失败:', error);
            throw error;
        }
    }

    async reinitVoiceSystems() {
        // 重新初始化语音系统
        if (window.app?.voiceManager) {
            console.log('🔄 重新初始化语音系统');
            try {
                // 确保语音管理器的音频上下文处于活动状态
                if (window.app.voiceManager.ensureAudioActive) {
                    await window.app.voiceManager.ensureAudioActive();
                }
            } catch (error) {
                console.warn('⚠️ 重新初始化语音系统时出错:', error);
            }
        }
    }

    showLoadingState() {
        // 显示加载状态（可通过AudioPermissionManager实现）
        if (window.app?.audioPermissionManager?.showLoading) {
            window.app.audioPermissionManager.showLoading();
        }
    }

    hidePermissionDialog() {
        // 隐藏权限对话框
        if (window.app?.audioPermissionManager?.hideDialog) {
            window.app.audioPermissionManager.hideDialog();
        }
    }

    showErrorFallback() {
        // 显示错误回退
        if (window.app?.audioPermissionManager?.showError) {
            window.app.audioPermissionManager.showError('音频系统初始化失败');
        }
    }

    async checkAndRequestAudioPermission() {
        // 检查并请求音频权限
        if (!this.audioEnabled) {
            await this.enableAudioSystem();
        }
    }
    
    // 公共方法：检查音频是否已启用
    isAudioEnabled() {
        return this.audioEnabled;
    }
    
    // 公共方法：激活WebXR音频解决方案
    activate() {
        console.log('🔊 WebXRAudioSolution已激活');
        // 确保音频上下文处于活动状态
        this.ensureAudioActive();
        // 如果音频系统尚未启用，则启用它
        if (!this.audioEnabled) {
            this.enableAudioSystem().catch(err => {
                console.warn('⚠️ 激活时启用音频系统失败:', err);
            });
        }
    }
}

// 创建单例实例
const webXRAudioSolution = new WebXRAudioSolution();
// 只导出单例实例作为默认导出，避免冲突
export default webXRAudioSolution;
export { webXRAudioSolution };

// 为了方便全局访问，在window上也暴露一下
if (!window._webXRAudioSolution) {
    window._webXRAudioSolution = webXRAudioSolution;
}